package extend_widget

import (
	"clientDemo/ui/fyne_ui/common"
	"clientDemo/ui/fyne_ui/widget"
	widgetcommon "clientDemo/ui/fyne_ui/widget/interface"
	widgetinterface "clientDemo/ui/fyne_ui/widget/interface"
	"fmt"
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/driver/desktop"
	fyneWidget "fyne.io/fyne/v2/widget"
	"image/color"
	"strconv"
	"strings"
)

// 注册控件
func init() {
	widget.RegWidget("WidgetInputBox", "输入框2", NewInputBox)
}

// InputBox 输入框控件
type InputBox struct {
	*WidgetContainer
	*Action
	widgetinterface.IUserInfo
	rootNode widgetinterface.IWidgetItem

	// 输入框属性
	Text        string
	FontSize    float32
	TextColor   color.RGBA
	Width       float32
	Height      float32
	Placeholder string
	IsEditable  bool

	// 内部输入框对象
	entry *fyneWidget.Entry
}

// NewInputBox 创建输入框控件
func NewInputBox(name string, skinInfo widgetinterface.IWidgetSkin, rootNode widgetinterface.IWidgetItem) widgetinterface.IWidgetItem {
	if skinInfo == nil {
		return nil
	}

	// 创建Fyne的Entry控件
	baseEntry := fyneWidget.NewEntry()

	_inputBox := &InputBox{
		WidgetContainer: &WidgetContainer{
			Container: &Container{
				name: name,
			},
			Border: canvas.NewRectangle(color.RGBA{0, 0, 0, 0}), // 初始化Border
		},
		Action:   &Action{},
		rootNode: rootNode,

		// 默认值
		Text:        name,
		FontSize:    14,
		TextColor:   color.RGBA{0, 0, 0, 255},
		Width:       200,
		Height:      30,
		Placeholder: "请输入文本",
		IsEditable:  true,
	}

	// 从皮肤信息中读取属性
	_inputBox.loadFromSkin(skinInfo)

	// 设置输入框属性
	_inputBox.applyProperties(baseEntry)

	// 初始化IUserInfo
	_inputBox.IUserInfo = common.NewWidgetUserInfo(name, skinInfo.GetSkinName(), _inputBox)
	_inputBox.WidgetContainer.Container.IUserInfo = _inputBox.IUserInfo
	_inputBox.WidgetContainer.ac = _inputBox.Action
	_inputBox.WidgetContainer.SetObjects([]fyne.CanvasObject{baseEntry})
	_inputBox.SetBase(_inputBox, rootNode)
	_inputBox.ExtendBaseWidget(_inputBox)

	_inputBox.entry = baseEntry

	return _inputBox
}

// loadFromSkin 从皮肤信息中加载属性
func (i *InputBox) loadFromSkin(skinInfo widgetinterface.IWidgetSkin) {
	if skinInfo == nil {
		return
	}

	// 从属性列表中查找属性
	attributes := skinInfo.GetAttribute()
	for _, attr := range attributes {
		switch attr.Key {
		case "Text":
			i.Text = attr.Value
		case "FontSize":
			if fontSize, err := strconv.ParseFloat(attr.Value, 32); err == nil {
				i.FontSize = float32(fontSize)
			}
		case "TextColor":
			i.TextColor = i.parseColor(attr.Value)
		case "Width":
			if width, err := strconv.ParseFloat(attr.Value, 32); err == nil {
				i.Width = float32(width)
			}
		case "Height":
			if height, err := strconv.ParseFloat(attr.Value, 32); err == nil {
				i.Height = float32(height)
			}
		case "Placeholder":
			i.Placeholder = attr.Value
		case "IsEditable":
			if isEditable, err := strconv.ParseBool(attr.Value); err == nil {
				i.IsEditable = isEditable
			}
		}
	}
}

// parseColor 解析颜色字符串
func (i *InputBox) parseColor(colorStr string) color.RGBA {
	parts := strings.Fields(colorStr)
	if len(parts) >= 3 {
		// 解析RGB值
		r, _ := strconv.Atoi(parts[0])
		g, _ := strconv.Atoi(parts[1])
		b, _ := strconv.Atoi(parts[2])
		a := 255 // 默认不透明

		// 如果有4个参数，第四个参数是alpha值
		if len(parts) == 4 {
			a, _ = strconv.Atoi(parts[3])
		}

		return color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)}
	}
	return color.RGBA{0, 0, 0, 255} // 默认黑色
}

// applyProperties 应用属性到输入框
func (i *InputBox) applyProperties(entry *fyneWidget.Entry) {
	entry.SetText(i.Text)
	entry.PlaceHolder = i.Placeholder
	entry.Resize(fyne.NewSize(i.Width, i.Height))

	// 根据编辑模式设置是否可编辑
	// 在编辑模式下禁用输入，在非编辑模式下允许输入
	if widgetcommon.IsEditMode {
		entry.Disable() // 编辑模式下禁用输入，只能拖动
	} else {
		if i.IsEditable {
			entry.Enable() // 非编辑模式下允许输入
		} else {
			entry.Disable() // 如果IsEditable为false，则禁用
		}
	}
}

// SetProperty 设置属性
func (i *InputBox) SetProperty(key, value string, isProperty bool) {
	// 先处理输入框特定属性
	switch key {
	case "Text":
		i.Text = value
		i.entry.SetText(value)
		i.Refresh()
	case "FontSize":
		if fontSize, err := strconv.ParseFloat(value, 32); err == nil {
			i.FontSize = float32(fontSize)
			// Fyne Entry没有直接设置FontSize的方法，需要通过Theme或自定义Renderer
			// 暂时不实现动态FontSize，因为Fyne Entry的字体大小受Theme控制
			i.Refresh()
		}
	case "TextColor":
		i.TextColor = i.parseColor(value)
		// Fyne Entry没有直接设置TextColor的方法，需要通过Theme或自定义Renderer
		i.Refresh()
	case "Width":
		if width, err := strconv.ParseFloat(value, 32); err == nil {
			i.Width = float32(width)
			i.entry.Resize(fyne.NewSize(i.Width, i.Height))
			i.Refresh()
		}
	case "Height":
		if height, err := strconv.ParseFloat(value, 32); err == nil {
			i.Height = float32(height)
			i.entry.Resize(fyne.NewSize(i.Width, i.Height))
			i.Refresh()
		}
	case "Placeholder":
		i.Placeholder = value
		i.entry.PlaceHolder = value
		i.Refresh()
	case "IsEditable":
		if editable, err := strconv.ParseBool(value); err == nil {
			i.IsEditable = editable
			i.UpdateEditMode() // 更新编辑模式状态
			i.Refresh()
		}
	default:
		// 其他属性交给父类处理
		i.WidgetContainer.SetProperty(key, value, isProperty)
	}
}

// GetProperty 获取属性
func (i *InputBox) GetProperty(key string) string {
	switch key {
	case "Text":
		return i.Text
	case "FontSize":
		return strconv.FormatFloat(float64(i.FontSize), 'f', 2, 32)
	case "TextColor":
		return i.formatColor(i.TextColor)
	case "Width":
		return strconv.FormatFloat(float64(i.Width), 'f', 2, 32)
	case "Height":
		return strconv.FormatFloat(float64(i.Height), 'f', 2, 32)
	case "Placeholder":
		return i.Placeholder
	case "IsEditable":
		return strconv.FormatBool(i.IsEditable)
	default:
		// IUserInfo没有GetProperty方法，返回空字符串
		return ""
	}
}

// formatColor 格式化颜色为字符串
func (i *InputBox) formatColor(c color.RGBA) string {
	// 假设非透明颜色都带1作为前缀
	if c.A == 0 {
		return fmt.Sprintf("0 %d %d %d", c.R, c.G, c.B)
	}
	return fmt.Sprintf("1 %d %d %d %d", c.R, c.G, c.B, c.A)
}

// ForEachProperty 遍历属性
func (i *InputBox) ForEachProperty(cb func(k, v string)) {
	i.IUserInfo.ForEachProperty(func(key, value string) {
		cb(key, value)
	})
	cb("Text", i.Text)
	cb("FontSize", strconv.FormatFloat(float64(i.FontSize), 'f', 2, 32))
	cb("TextColor", i.formatColor(i.TextColor))
	cb("Width", strconv.FormatFloat(float64(i.Width), 'f', 2, 32))
	cb("Height", strconv.FormatFloat(float64(i.Height), 'f', 2, 32))
	cb("Placeholder", i.Placeholder)
	cb("IsEditable", strconv.FormatBool(i.IsEditable))
}

func (i *InputBox) ForEach(fn func(widgetinterface.IWidgetItem) bool) {
	// 输入框控件通常不包含子控件
}

func (i *InputBox) GetCanvasObject() fyne.CanvasObject {
	// 返回输入框控件本身
	return i
}

// 鼠标事件处理 - 简化版本，直接使用Action处理拖动
func (i *InputBox) MouseDown(event *desktop.MouseEvent) {
	// 在编辑模式下，将事件传递给Action处理拖动
	if widgetcommon.IsEditMode {
		if i.Action != nil {
			fmt.Printf("[InputBox] MouseDown - 编辑模式，传递给Action\n")
			i.Action.MouseDown(event)
		}
		return
	}

	// 非编辑模式下，可以处理其他逻辑
}

func (i *InputBox) MouseUp(event *desktop.MouseEvent) {
	// 在编辑模式下，将事件传递给Action处理拖动
	if widgetcommon.IsEditMode {
		if i.Action != nil {
			fmt.Printf("[InputBox] MouseUp - 编辑模式，传递给Action\n")
			i.Action.MouseUp(event)
		}
		return
	}

	// 非编辑模式下，可以处理其他逻辑
}

func (i *InputBox) MouseMoved(event *desktop.MouseEvent) {
	// 在编辑模式下，将事件传递给Action处理拖动
	if widgetcommon.IsEditMode {
		if i.Action != nil {
			i.Action.MouseMoved(event)
		}
		return
	}

	// 非编辑模式下，可以处理其他逻辑
}

// 实现fyne.Widget接口
func (i *InputBox) CreateRenderer() fyne.WidgetRenderer {
	return i.WidgetContainer.CreateRenderer()
}

func (i *InputBox) MinSize() fyne.Size {
	return i.WidgetContainer.MinSize()
}

func (i *InputBox) Position() fyne.Position {
	return i.WidgetContainer.Position()
}

func (i *InputBox) Size() fyne.Size {
	return i.WidgetContainer.Size()
}

func (i *InputBox) Move(pos fyne.Position) {
	i.WidgetContainer.Move(pos)
}

func (i *InputBox) Move2(pos fyne.Position) {
	i.WidgetContainer.Move2(pos)
}

func (i *InputBox) Hidden() bool {
	return !i.WidgetContainer.Visible()
}

func (i *InputBox) SetVisible(visible bool) {
	if visible {
		i.WidgetContainer.Show()
	} else {
		i.WidgetContainer.Hide()
	}
}

func (i *InputBox) Show() {
	i.WidgetContainer.Show()
}

func (i *InputBox) Hide() {
	i.WidgetContainer.Hide()
}

func (i *InputBox) Visible() bool {
	return i.WidgetContainer.Visible()
}

func (i *InputBox) Cursor() desktop.Cursor {
	return desktop.DefaultCursor
}

func (i *InputBox) SetCursor(cursor desktop.Cursor) {
	// 输入框的鼠标样式通常不需要修改
}

// UpdateEditMode 更新编辑模式状态
func (i *InputBox) UpdateEditMode() {
	// 直接使用内部entry对象更新状态
	if i.entry != nil {
		// 根据编辑模式设置是否可编辑
		if widgetcommon.IsEditMode {
			i.entry.Disable() // 编辑模式下禁用输入，只能拖动
		} else {
			if i.IsEditable {
				i.entry.Enable() // 非编辑模式下允许输入
			} else {
				i.entry.Disable() // 如果IsEditable为false，则禁用
			}
		}
	}
}
